Mitigation of disocclusion artifacts

ABSTRACT

Image based imposters suffer from common errors called disocclusion artifacts where portions of the scene that should be occluded by real geometry are visible when using image based imposters. These artifacts are the result of parallax error created by camera motion where regions of a mesh that were not visible at the time of imposter generation have become visible. A computationally inexpensive on-line technique to resolve these disocclusions stretches existing imposter texture information over new geometry bridging the gap between imposters.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority to U.S. Provisional Application Ser.No. 62/084,242, filed on Nov. 25, 2014, entitled “MITIGATION OFDISOCCLUSION ARTIFACTS”, the entirety of which is incorporated herein byreference.

BACKGROUND

Graphics cards are consistently improving in speed and performance, butthey are being outpaced by the growth of big data and, in particular,the output of remote sensing technologies. For example, point cloudsreturned by technologies like Light Detection and Ranging (LiDAR) arebecoming increasingly important in diverse fields such as robotics,agriculture, archaeology, renewable energy, and the like where data hasa spatial component. This gap requires new techniques to relaxcomputational requirements while providing a sufficiently useful output.

Current image based level-of-detail techniques attempt to solve theabove problem, however, these techniques suffer from a number ofdeficiencies. One such technique, image based imposters, represents animpersonated object by a textured quadrilateral positioned such that theprojection of the 3D geometry onto a 2D surface produces an identicalresult. The fundamental failures in this technique are errors createdwhen the camera position moves from where the imposter was originallygenerated. Because these errors show regions of space that should haveotherwise been occluded, they are often referred to as disocclusionartifacts. FIGS. 1 and 2 illustrate an example of these disocclusions.FIG. 1 shows full fidelity data from an original camera position, whileFIG. 2 illustrates imposters with disocclusions 200 resulting from achanged camera position.

Layered depth images (LDIs) attempt to reduce these parallax errors bygenerating a texture that stores multiple depth values per texel. As thecamera moves, an incremental warping function determines which depthlayer will be exposed for a given pixel. However, this technique isespecially prone to sampling artifacts. While this may not be majorissue for some polygonal models, missing even a single pixel for pointclouds can drastically alter data. Additionally, this technique isintended to be computed offline and, therefore, cannot handlemodifications made to the data during runtime.

Unlike standard imposters which use a single quadrilateral, textureddepth meshes (TDMs) create a new polygonal mesh, of many fewer faces,through a voxel based sampling scheme from a particular viewpoint.However, similar to LDIs, the generation step is very slow and must beperformed offline. TDMs also have a very high spatial requirement forsituations where the camera position is not severely restricted.

More recently, occlusion cameras have become popular. Unlike a planarpinhole camera model, the occlusion camera model uses curved rays toinspect beyond the edges of objects, so that slightly occluded fragmentsare known in advance. This technique also has a few drawbacks that makeit unsuitable for point clouds: first, it does not work well with dataincluding large, sudden changes in depth information; and second, theresolution of the output image is reduced because of the multiplesamples along each ray. Additionally, in the general case, it cannotguarantee that all disocclusions are resolved, especially for largemovements of the camera. In light of these issues, planar pinhole cameramodels are also not suitable for runtime modifications of point clouddata.

BRIEF SUMMARY

According to one example described herein, a method for generatingimages includes: forming a bridge between a sequence of a plurality ofpoints, each consecutive pair of the sequence of points being pointsalong an interface between two adjacent sub-meshes replaced byimage-based imposters, wherein the plurality of points have the samescreen space position and different world space positions when projectedinto the plane of the imposter; generating content of textures to bemapped onto the image-based imposters; and computing texture coordinatesfor a generation position and a second camera position.

In various embodiments of the above example, the step of forming abridge includes: constructing an artificial interface of world spacepoints along the natural interface between the two adjacent sub-meshes;projecting the world space points into screen space positions;reassigning the screen space positions depth coordinates of twodestination imposter planes; and transforming the screen space positionsback into world space; the step of forming a bridge includesconstructing an artificial interface of world space points along theinterface between the two adjacent sub-meshes, the artificial interfaceof world space points being constructed using a strip tree; the step offorming a bridge includes constructing an artificial interface of worldspace points along the interface between the two adjacent sub-meshes,the artificial interface of world space points being constructed using aBezier curve; the step of forming a bridge includes constructing anartificial interface of world space points along the interface betweenthe two adjacent sub-meshes, the artificial interface of world spacepoints being constructed using a basis spline; the step of computingtexture coordinates for a second camera position includes: stretchingthe texture over the imposter, wherein the texture is stretched based ona weighted metric such that as bridge segments of the imposter becomesvisible the stretching of the texture increases; the method is appliedto a point cloud split into a plurality of meshes; the two points arestored in memory and the method is executed by a processor; the methodfurther includes displaying the generated image on a monitor; and/or theimage is generated in real-time based on a dataset, as the dataset isbeing modified.

According to another example described herein, an apparatus forgenerating an image includes: a bridge forming section configured toform a bridge between a sequence of a plurality of points, eachconsecutive pair of the sequence of points being points along aninterface between two adjacent sub-meshes replaced by image-basedimposters, wherein the plurality of points have the same screen spaceposition and different world space positions when projected into theplane of the imposter; a texture generating section configured togenerate textures to be mapped onto the image-based imposters; and atexture computing section configured to compute texture coordinates fora generation position and a second camera position.

In various embodiments of the above example, the bridge forming sectionis further configured to: construct an artificial interface of worldspace points along the natural interface between the two adjacentsub-meshes; project the world space points into screen space positions;reassign the screen space positions depth coordinates of two destinationimposter planes; and transform the screen space positions back intoworld space; the bridge forming section is further configured toconstruct an artificial interface of world space points along theinterface between the two adjacent sub-meshes, the artificial interfaceof world space points being constructed using a strip tree; the bridgeforming section is further configured to construct an artificialinterface of world space points along the interface between the twoadjacent sub-meshes, the artificial interface of world space pointsbeing constructed using a Bezier curve; the bridge forming section isfurther configured to construct an artificial interface of world spacepoints along the interface between the two adjacent sub-meshes, theartificial interface of world space points being constructed using abasis spline; for the second camera position, the texture computingsection is further configured to: stretch the texture over the imposter,wherein the texture is stretched based on a weighted metric such that asbridge segments of the imposter becomes visible the stretching of thetexture increases; the apparatus further includes a display fordisplaying the generated image; and/or the image is generated inreal-time based on a dataset, as the dataset is being modified.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an image with full fidelity data from an originalcamera position.

FIG. 2 illustrates imposters with disocclusions resulting from adifferent camera position than shown in FIG. 1.

FIG. 3 illustrates ideal imposters with parallax error.

FIG. 4 illustrates disocclusions solved with an embodiment of thepresent disclosure.

FIG. 5 illustrates imposters with a single segment strip tree and thegaps created in the texture.

FIGS. 6A, 6B, and 6C illustrate texture coordinates in one and twodimensions according to an embodiment of the present disclosure.

FIGS. 7A and 7B illustrate example of errors for the Haar Wavelet metricfor classic and decimated level-of-detail techniques compared to thetechnique described herein.

FIG. 8 illustrates a flow chart indicating a method to generate an imagefrom point cloud data.

FIG. 9 illustrates an apparatus for generating an image.

DETAILED DESCRIPTION

The present disclosure introduces an image based level-of-detailtechnique that resolves disocclusions and is suitable for point clouddata updated in an online manner during runtime. The technique alsoprovides an analysis of the output images based on a variety of modernimage quality metrics. While the technique described herein is explainedwith respect to point cloud data (e.g., datasets with gradual z-axisdeviations such as outdoor terrain scenes) it is to be understood thatthe technique is also envisioned to be adapted to constrain error formore erratic scenes and other sets of data, irrespective of content. Anexample implementation presented herein operates on a point cloud whichhas already been split into equal sized meshes to assist with frustumculling. To simplify the update scheme, 60 meshes were used (laid out ina 12×5 grid to approximate the extents of the cloud), so all mesheswould be updated in one second if one mesh was updated per frame, on avertically synced 60 Hz display.

In a first aspect of the technique presented herein, a new geometry isused to cover disocclusions. In a second aspect, the content of atexture is mapped to the new surface geometry. In a third aspect, thetexture coordinates used on the new and existing geometry are addressed.

With respect to the first aspect directed to a new geometry used tocover disocclusions, a bridge is built at the screen space interfacebetween two sub-meshes to cover the disocclusions between the worldspace positions. For example, when two adjacent sub-meshes are replacedby image-based imposters, the points along the interface between themesh lie in both imposters at the same screen space position; however,these points have two different world space positions when projectedinto the plane of the imposter. The bridge is formed between these twinworld space points. This new geometry effectively solves thedisocclusion by filling in all gaps, but the content of these newfragments does not necessarily match the content of the impersonatedscene. However, such a sacrifice in fidelity can increase interactivityand is consistent with the philosophy behind level-of-detail techniques.

While the geometry of ideal image imposters is a single quadrilateral,the geometry of the new imposters is designed to form a continuoussurface over the entire on-screen area covered by the original set ofmeshes. This surface can be broken down into a collection oftri-sectioned imposters (in one direction), with a section forming themain imposter face, and two sections representing half of the bridgesbetween meshes. In order to capture the relevant portion of the screenspace area, a strip tree of world space points may be constructed alongthe interface between the two meshes. In other embodiments, a Béziercurve, basis spline, or other curve could be used instead of or inaddition to a strip tree to construct an artificial interface betweenthe two meshes; however, the use of a strip tree is described herein forillustrative purposes. The world space points are then projected intotheir screen space positions. These screen space positions arereassigned the depth coordinates of the two destination imposter planesand then transformed back into world space. These bridges, between theworld space twins of the interface between meshes, fully cover thedisocclusion region caused by parallax motion of the camera.

FIGS. 3 and 4 illustrate an example of this new geometry with extremecamera motion, to highlight the creation of the disocclusions in bothdirections. FIG. 3 shows ideal imposters with parallax error and FIG. 4illustrates disocclusions solved with the new geometry. The shadedsections of FIG. 4 represent the connections between each segment of astrip tree, as discussed in more detail below. FIG. 5 illustrates apossible desire for a complex interface by showing the imposters with asingle segment strip tree (straight line) and the gaps created in thetexture. While two examples of disocclusions 500 are noted, severalothers are present.

The main face of the imposter is no longer a single quadrilateral, butrather a collection of quadrilaterals connecting the two strip trees.For simplicity, all strip trees in the example implementation hereinused the same fidelity, however, the fidelity can be adjusted per-meshbased on deviations in the height of the interface. Similarly, thefidelity of the strip tree can be changed based on the polygon budget ofthe scene. It is also noted that the texture on the imposter is not tiedto the strip tree fidelity. Thus, the strip tree geometry can be changedwithout requiring regeneration of the texture. Because strip treeconstruction can be done in O(n) time for already sorted points (e.g.,the content of a previous strip tree), this step can be done as part ofonline algorithm during runtime.

With respect to the second aspect of the technique described, thecontent of textures mapped onto the imposter is generated by calculatingthe axis aligned screen space size of the mesh and using a frame bufferobject with a render buffer of identical size. This creates a one-to-onemapping between pixels in the original mesh rendering and pixels in theimposter when applied to a quadrilateral positioned such that its screenspace size is also identical. As discussed in more detail below, thiscan lead to pixelation as the camera draws closer to the imposter oncethe one-to-one mapping no longer holds, until the texture isregenerated. If sufficient graphics memory is available, larger thannecessary textures could be used to mitigate such pixelation.

With respect to the third aspect of the technique described herein, twosets of texture coordinates are computed. The first set of texturecoordinates is for the generation position, and a second set of texturecoordinates accounts for a camera motion. Since the axis aligned screenspace extents were already calculated to determine the size of the framebuffer object's render buffer, and the screen space positions of thestrip tree geometry were already calculated to create the bridge endpoints, the texture coordinates at the generation position may becomputed. A screen space point at the lower left extent (which may ormay not exist) would have a (u,v) coordinate of (0,0) and a screen spacepoint at the upper right would have a (u,v) coordinate of (1,1); pointsin between are assigned coordinates proportionately.

Mapping the texture to the new geometry includes stretching the idealimposter texture over the main imposter face and bridge segments. Ametric can be created to determine how much a texture should bestretched over these surfaces by weighting the bridge segments. At thegeneration position, the imposter method presented herein can lookidentical, or nearly identical, to classic imposters. Because the bridgeconnects identical screen space points at the generation position, theon screen size of the bridge segments at the generation position can beconsidered zero and, therefore, no stretching is required. As the cameramoves and the bridge segments become visible, the weight given to thebridge segments increases, and the texture stretches over the geometry.

Thus far, the above discussion has only covered stretching the texturesin one direction. However, texture stretching in two directions is alsopossible. The same screen space size metric, as discussed above, can beused for texture weights (O. However, these weights are used to stretchthe texture in two, typically oblique, directions. An approximation isused based on an oblique projection of the texture coordinates into acoordinate frame using the difference in texture coordinates of thecorners as basis vectors (U and V). Since the opposing edges of the mainface should be roughly parallel, the same basis vectors can be used forall four corners to reduce computation. However, if desired for aparticular application, recalculating for each corner may yield someimprovements. Equations 1 and 2 provide an example of how to calculatethe coordinates in this new frame, u_(i) and v_(i), given startingtexture coordinates T_(i) and the oblique basis vectors. It should benoted that the example given in equations 1 and 2 only represent one ofmany possible ways of stretching the texture and, therefore, should notbe viewed as a limiting embodiment. The new texture coordinates τ_(i),as shown in FIGS. 6A-6C for one and two directions, are computed as aweighted bilinear interpolation using the oblique coordinates, u_(i) andv_(i), as well as the texture stretching weights μ_(i); with i from [0 .. . 3] and j from [0 . . . 2]. In two directions there are separatetexture weights in the U and V directions.

$\begin{matrix}{u_{i} = \frac{{U \cdot T_{i}} - \left( {{U \cdot V}*{V \cdot T_{i}}} \right)}{1 - \left( {U \cdot V} \right)^{2}}} & (1) \\{v_{i} = \frac{{V \cdot T_{i}} - \left( {{V \cdot U}*{U \cdot T_{i}}} \right)}{1 - \left( {U \cdot V} \right)^{2}}} & (2)\end{matrix}$

The calculation of the new texture coordinates shown in FIGS. 6A-6C canbe simplified if the imposter face contained strictly relevant textureinformation and, therefore, had texture coordinates in the range (0,0) .. . (1,1), or if the U and V were orthogonal. If there is any deviationin the interface between meshes, then the texture can contain somecontent unsuitable for stretching, and a more complicated set ofequations, such as those above, may be used.

A series of experiments analyzed the quality of the technique describedherein as compared to two competing techniques: decimation, the mostcommon form of level-of-detail for point cloud rendering, and classicimposters. The point cloud used for the experiment contained 12,212,086points, and was divided into 60 equal sized meshes. One imposter wasupdated per frame in a hybrid screen-space/least recently used method.For these tests a constant sized strip tree was used. However, it shouldbe noted that other possible strip tree methodologies may be used, asdescribed below. The testing platform for the initial timing tests was alaptop with an NVidia 280M graphics card, a 2.67 GHz Intel Core i7processor, with 6 GB of RAM.

In order to create a valid comparison, a decimation rate of 30:1 wasselected in order to match the frame rate of the imposter techniques onthe timing test platform. Error was calculated as a series of imagecomparison metrics between the full fidelity set and the three testtechniques. A predetermined flight path containing 900 frames wasgenerated using each technique and these frames were used in the imagecomparison metrics described below.

The simplest metric tested was a pixel-by-pixel root mean square errordifference in luminosity. A very similar approach converts the pixelsinto the perceptually uniform CIELAB space and calculates the errorbased on the Euclidian distance between the like indexed pixels in eachimage. In an attempt to better capture features humans find desirable,the hue angle metric creates a color histogram and weights pixelsbelonging to the more common colors more heavily. This is to simulatelarge patches of the same colors which are probably more important tothe user. The Spatial Hue Angle Metric (SHAMe) improves upon the hueangle metric to better model the human visual system by passing theinput images through a spatial filter in order to ignore very highfrequency noise that human users would likely ignore. This iseffectively a low pass filter based on a contrast sensitivity functionoperating on the frequency space representation of the image.

The latter two metrics are asymmetric—that is, running the metric, M, onimages I₁ and I₂, will give a different result than running M on I₂ andI₁. During analysis, these metrics are used twice: once as a measure ofhow different the modified image is from the original and once as ameasure of how different the images are from each other, derived fromthe mean of running the metric in either direction.

The final metric is based on the Haar wavelet. In this metric, half ofthe weight of the output value is given to the average of the entireimage, a quarter of the weight is given to average of image quarters, aneighth of the weight is given to the average of the image sixteenths,etc. This makes the metric very robust to slight movement and roundofferrors in the positions of the imposter texels.

Tests were run at three different resolutions, including two differentaspect ratios: 800×600, 1024×768, and 1280×720. Results were comparable,so only the results for 1024×768 are given here. Table 1 contains theabsolute error values for all metrics and rendering styles at thisresolution, as well as the relative error percentages for the twoimposter techniques. FIGS. 7A and 7B show an example of errors for theHaar Wavelet metric for all three level-of-detail techniques (classic,new, and decimated) for the 1024×768 resolution images. The horizontalaxis of FIGS. 7A and 7B indicates a frame number and the vertical axisis the absolute error.

Metric Decimation Classic New Relative RMS 3.1015 1.1829 1.1323 95.724Haar 3.0017 0.8324 0.7819 93.935 Δ * E 1.8937 0.9657 0.9443 97.782 HueAngle One-way 0.9831 0.4937 0.4822 97.681 Hue Angle Two-way 1.05830.4961 0.4837 97.491 Spatial Hue Angle 1.1755 0.3777 0.3616 95.732

For the six metrics used, the imposters using the disclosed disocclusionmitigation technique outperform the classic imposter and decimatedapproaches. The Haar Wavelet metric has the largest separation innormalized values of any of the metrics, implying that this metric mightbe a good choice for evaluating image similarity problems. Tests wererun with multiple resolutions and results were comparable for allresolutions. Even though the difference in error between approaches wasquantitatively small, the results may be much more pleasing to users.

Another characteristic indicated by the graphs in FIGS. 7A and 7B isthat, according to at least the Haar metric, in addition to beingsmaller, the error appears to be smoother than the classic imposter.This quality should provide a more pleasing experience to a user.

There are several sources of error that may cause the error metricvalues to inflate and diverge from actual human perception. The firstlikely results from older hardware and is caused by a difference indepth buffer precision between the main render buffer and frame bufferobjects. A source of error that is common to many image-based renderingtechniques that rely on a static image, for some period of time, ispixelation when the number of pixels on screen surpasses the number ofpixels in the image. This can be ameliorated by using a larger thannecessary render buffer when generating the image. However, thisrequires more texture memory, and likely more rendering time whengenerating.

Complete coverage of the disocclusion would require a high fidelitystrip tree; however, for these experiments all strip trees used aconstant size (10 segments). This number of segments is quite generousfor most of the segments in the given terrain set, but for asufficiently erratic interface, gaps may still be present.

The screen space texture weighting metric can also introduce occasionalerrors when very long screen space bridge segments that should have hadzero area have their minor axis dimension rounded to 1 pixel. This canusually be avoided heuristically. However, this problem is exacerbatedwhen meshes become larger on screen, and is the primary cause for theincrease in relative error towards the end of the flight path in FIG. 7.

It should be noted that there are many variations of the aboveenvisioned to be within the scope of the present disclosure. Forexample, it may be desirable to include a dynamic use of the striptrees. That is, it may be possible to use more segments for more erraticinterfaces or dynamically adjust strip tree fidelity based on polygonbudgets to maintain a specific frame rate. Dynamic placement of theconnective geometry between two meshes or, more creatively, creating onelarge surface with texture control points, for all the meshes is alsoenvisioned.

It is additionally noted that any of the aspects, or combination ofaspects, described above may be implemented via hardware or software.For example, these aspects may be implemented on a processor or aplurality of processors, such as a graphics processing unit (GPU) orsimilar dedicated graphics processor. These processors also may beembedded or integrated with other processors designed for a separatepurpose, for example, as part of a central processing unit (CPU). A“processor” as used herein refers to any, or part of any, electricalcircuit comprised of any number of electrical components, including, forexample, resistors, transistors, capacitors, inductors, and the like.The circuit may be of any form, including, for example, an integratedcircuit, a set of integrated circuits, a microcontroller, amicroprocessor, a collection of discrete electronic components on aprinted circuit board (PCB) or the like. The processor may also standalone or be part of a computer used for operations other than processingimage data. Implementation of these aspects may by hardware or softwaremay be realized in any number of electronic devices and/or applications,including but not limited to, personal computers, servers, mobilephones, and the like. Moreover, the above aspects and/or combination ofaspects may be stored in memory which is executable by one of saidprocessors. It should be noted that the above description isnon-limiting, and the examples are but only a few of many possibleprocessors and implementations envisioned.

It should also be noted that the above aspects are intended to beimplemented for providing a display to a user. The end display may bevisible to the user, for example, for viewing the above-discussed pointcloud data. Such displays may include monitors or screens, including butnot limited to, liquid crystal displays (LCDs), light emitting diodedisplays (LEDs), cathode ray tube displays (CRTs), plasma displays, andthe like. In light of this, it is also understood that the display isconnected to and at least partially driven by the above noted hardwareand/or software, for example, GPU or CPU. That is, for example, acomputer for displaying point cloud data may include a motherboardhaving a CPU, a graphics card having a GPU, and a monitor. The monitormay be connected to the graphics card having a GPU, the graphics cardbeing further connected to the motherboard having a CPU. In this way,the CPU may operate on the point cloud data and, in conjunction with theGPU, provide a display output via the graphics card to the monitor fordisplaying the point cloud data to a user in accordance with the aboveaspects or combination of aspects of the present disclosure.

For example, FIG. 8 illustrates a flow chart indicating a method forimplementing the above described aspects, for example, to generate animage from point cloud data. In a first step 800, a bridge is formedbetween a sequence of points, as described with respect to the firstaspect. One optional approach for forming the bridge, as describedabove, may involve constructing an artificial interface of world spacepoints 802, projecting the world space points into screen spacepositions 804, reassigning the screen space positions depth coordinates806, and transforming the screen space positions back into world space808. According to the second aspect, textures are generated and mappedto the new surface geometry 810. Then, as described with respect to thethird aspect, texture coordinates for multiple camera positions arecomputed 812. This can include stretching the ideal imposter textureover the main imposter face and bridge segments 814. The resultant imagecan then be displayed 816.

Similarly, FIG. 9 illustrates an apparatus 900 for implementing theabove-described aspects to generate an image. The system 900 has atleast a processor (e.g., a CPU or GPU) 902 and a display 904. A bridgeforming section 906 of the processor 902 executes the first aspectdescribed herein, for example, forming a bridge between a sequence ofpoints 800. As described above with respect to FIG. 8, the bridge may beformed according to steps 802-808. The second aspect, for example,generating textures and mapping the textures to the new surfacegeometry, may be performed by the texture computing section 908. Thetexture generating section 910 performs the third aspect describedherein, for example, by computing texture coordinates for multiplecamera positions and stretching the texture over the imposters as insteps 812 and 814 of FIG. 8. The resulting image generated by theprocessor 902 can be shown on display 904.

With the above-described aspects and combinations thereof can improvethe functionality of both hardware on which they are implemented andtechnologies to which they are applied. For example, the above aspectsmay reduce the rendering resources required for displaying point clouddata (e.g., by 30 times). As noted above, the aspects described abovemay allow for real-time manipulation of point cloud data as it isrendered, thereby increasing efficiency and analysis of that data.

Certain terminology is used herein for convenience only and is not to betaken as a limitation on the present invention. Relative language usedherein is best understood with reference to the drawings, in which likenumerals are used to identify like or similar items. Further, in thedrawings, certain features may be shown in somewhat schematic form.

It is also to be noted that the phrase “at least one of”, if usedherein, followed by a plurality of members herein means one of themembers, or a combination of more than one of the members. For example,the phrase “at least one of a first widget and a second widget” means inthe present application: the first widget, the second widget, or thefirst widget and the second widget. Likewise, “at least one of a firstwidget, a second widget and a third widget” means in the presentapplication: the first widget, the second widget, the third widget, thefirst widget and the second widget, the first widget and the thirdwidget, the second widget and the third widget, or the first widget andthe second widget and the third widget. Finally, the term“substantially,” if used herein, is a term of estimation.

While various features are presented above, it should be understood thatthe features may be used singly or in any combination thereof. Further,it should be understood that variations and modifications may occur tothose skilled in the art to which the claimed examples pertain. Theexamples described herein are exemplary. The disclosure may enable thoseskilled in the art to make and use alternative designs havingalternative elements that likewise correspond to the elements recited inthe claims. The intended scope may thus include other examples that donot differ or that insubstantially differ from the literal language ofthe claims. The scope of the disclosure is accordingly defined as setforth in the appended claims.

1. A method for generating images comprising: forming a bridge between asequence of a plurality of points, each consecutive pair of the sequenceof points being points along an interface between two adjacentsub-meshes replaced by image-based imposters, wherein the plurality ofpoints have the same screen space position and different world spacepositions when projected into the plane of the imposter; generatingcontent of textures to be mapped onto the image-based imposters; andcomputing texture coordinates for a generation position and a secondcamera position.
 2. The method according to claim 1, wherein the step offorming a bridge comprises: constructing an artificial interface ofworld space points along the natural interface between the two adjacentsub-meshes; projecting the world space points into screen spacepositions; reassigning the screen space positions depth coordinates oftwo destination imposter planes; and transforming the screen spacepositions back into world space.
 3. The method according to claim 1,wherein the step of forming a bridge comprises constructing anartificial interface of world space points along the interface betweenthe two adjacent sub-meshes, the artificial interface of world spacepoints being constructed using a strip tree.
 4. The method accordingclaim 1, wherein the step of forming a bridge comprises constructing anartificial interface of world space points along the interface betweenthe two adjacent sub-meshes, the artificial interface of world spacepoints being constructed using a Bézier curve.
 5. The method accordingclaim 1, wherein the step of forming a bridge comprises constructing anartificial interface of world space points along the interface betweenthe two adjacent sub-meshes, the artificial interface of world spacepoints being constructed using a basis spline.
 6. The method accordingto claim 1, wherein the step of computing texture coordinates for asecond camera position comprises: stretching the texture over theimposter, wherein the texture is stretched based on a weighted metricsuch that as bridge segments of the imposter becomes visible thestretching of the texture increases.
 7. The method according to claim 1,wherein the method is applied to a point cloud split into a plurality ofmeshes.
 8. The method according to claim 1, wherein the two points arestored in memory and the method is executed by a processor.
 9. Themethod according to claim 1, further comprising displaying the generatedimage on a monitor.
 10. The method according to claim 1, wherein theimage is generated in real-time based on a dataset, as the dataset isbeing modified.
 11. An apparatus for generating an image comprising: abridge forming section configured to form a bridge between a sequence ofa plurality of points, each consecutive pair of the sequence of pointsbeing points along an interface between two adjacent sub-meshes replacedby image-based imposters, wherein the plurality of points have the samescreen space position and different world space positions when projectedinto the plane of the imposter; a texture generating section configuredto generate textures to be mapped onto the image-based imposters; and atexture computing section configured to compute texture coordinates fora generation position and a second camera position.
 12. The apparatusaccording to claim 11, wherein the bridge forming section is furtherconfigured to: construct an artificial interface of world space pointsalong the natural interface between the two adjacent sub-meshes; projectthe world space points into screen space positions; reassign the screenspace positions depth coordinates of two destination imposter planes;and transform the screen space positions back into world space.
 13. Theapparatus according to claim 11, wherein the bridge forming section isfurther configured to construct an artificial interface of world spacepoints along the interface between the two adjacent sub-meshes, theartificial interface of world space points being constructed using astrip tree.
 14. The apparatus according to claim 11, wherein the bridgeforming section is further configured to construct an artificialinterface of world space points along the interface between the twoadjacent sub-meshes, the artificial interface of world space pointsbeing constructed using a Bézier curve.
 15. The apparatus according toclaim 11, wherein the bridge forming section is further configured toconstruct an artificial interface of world space points along theinterface between the two adjacent sub-meshes, the artificial interfaceof world space points being constructed using a basis spline.
 16. Theapparatus according to claim 11, wherein, for the second cameraposition, the texture computing section is further configured to:stretch the texture over the imposter, wherein the texture is stretchedbased on a weighted metric such that as bridge segments of the imposterbecomes visible the stretching of the texture increases.
 17. Theapparatus according to claim 11, further comprising a display fordisplaying the generated image.
 18. The apparatus according to claim 11,wherein the image is generated in real-time based on a dataset, as thedataset is being modified.